home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
FishMarket 1.0
/
FishMarket v1.0.iso
/
fishies
/
201-225
/
disk_214
/
mandelvroom
/
src
/
cycle.c
< prev
next >
Wrap
C/C++ Source or Header
|
1992-05-06
|
13KB
|
579 lines
/*
* MandelVroom 2.0
*
* (c) Copyright 1987,1989 Kevin L. Clague, San Jose, CA
*
* All rights reserved.
*
* Permission is hereby granted to distribute this program's source
* executable, and documentation for non-comercial purposes, so long as the
* copyright notices are not removed from the sources, executable or
* documentation. This program may not be distributed for a profit without
* the express written consent of the author Kevin L. Clague.
*
* This program is not in the public domain.
*
* Fred Fish is expressly granted permission to distribute this program's
* source and executable as part of the "Fred Fish freely redistributable
* Amiga software library."
*
* Permission is expressly granted for this program and it's source to be
* distributed as part of the Amicus Amiga software disks, and the
* First Amiga User Group's Hot Mix disks.
*
* contents: this file contains the code to open and close the color
* cycling tool. It also contains the functions that implement the color
* cycling commands.
*/
#include "mandp.h"
#include <ctype.h>
#define PENLEFT 8
#define PENTOP 15
UBYTE CycleOpen;
/*
* Holder for Allocated color potentiometer gadgets.
*/
struct Gadget *SpeedPot;
struct Gadget *DirGadget;
struct Gadget *CycleOnGadget;
struct Gadget *CycleOffGadget;
struct Window *CycWind;
struct NewWindow NewCyc = {
128,70, /* start position */
164,80, /* width, height */
(UBYTE) 0, (UBYTE) -1, /* detail pen, block pen */
NULL, /* IDCMP flags */
/* MandWind flags */
WINDOWCLOSE | WINDOWDRAG | WINDOWDEPTH | NOCAREREFRESH | SMART_REFRESH,
(struct Gadget *) NULL, /* first gadget */
(struct Image *) NULL, /* user checkmark */
(UBYTE *) "Cycling", /* window title */
(struct Screen *) NULL, /* pointer to screen */
(struct BitMap *) NULL, /* pointer to superbitmap */
80,80,80,80, /* sizing */
CUSTOMSCREEN /* type of screen */
};
int EditRange;
int RangeFirstPen;
SlideSpeedCmd(Msg)
struct IntuiMessage *Msg;
{
struct Gadget *gadget;
gadget = (struct Gadget *) Msg->IAddress;
switch( Msg->Class ) {
case GADGETDOWN: /* Start Speed slide */
if (CurPict->CycleOn == 0)
CreateCycle();
ModifyIDCMP(CycWind,(long) CycWind->IDCMPFlags | MOUSEMOVE);
State = SLIDESPEEDSTATE;
break;
case MOUSEMOVE: /* change the speed */
SetSpeed();
break;
case GADGETUP: /* Stop Speed slide */
if (CurPict->CycleOn == 0) {
KillCycle();
LoadRGB4(vp, CurPict->RGBs, Num_vp_Colors);
}
SetSpeed();
ModifyIDCMP(CycWind,(long) CycWind->IDCMPFlags & ~MOUSEMOVE);
State = IDLESTATE;
break;
}
}
CycleRangeCmd(Msg)
struct IntuiMessage *Msg;
{
struct Gadget *gadget;
int id;
/* Need contour selection to complete */
gadget = (struct Gadget *) Msg->IAddress;
id = gadget->GadgetID;
if (Msg->Class == GADGETDOWN) {
if (id == CYCRANGE) {
StopCycle();
/* Color Palette command picks up the finish of the range cmd*/
if (CurPen < Num_vp_Colors) {
SetToPointer();
RangeFirstPen = CurPen;
State = CYCLERANGESTATE;
} else {
DispErrMsg("Can't set color cycle with hafbrite pens",0);
}
} else
if (WIND_TYPE(id) == PALTYPE && GADG_TYPE(id) == PALPENS) {
FinishRangeCmd(GADG_NUM(id));
State = IDLESTATE;
}
}
}
ToggleDirCmd(Msg)
struct IntuiMessage *Msg;
{
struct Gadget *gadget = (struct Gadget *) Msg->IAddress;
StopCycle();
/* Set Direction into current cycle info structure */
if (gadget->Flags & SELECTED) {
CurPict->Crngs[ EditRange ].active &= ~REVERSE;
} else {
CurPict->Crngs[ EditRange ].active |= REVERSE;
}
State = IDLESTATE;
}
CycleOnOffCmd(Msg)
struct IntuiMessage *Msg;
{
if (CurPict == NULL)
return;
if (CurPict->CycleOn) {
StopCycle();
} else {
CreateCycle();
CurPict->CycleOn = 1;
SetOnString(1);
}
State = IDLESTATE;
}
StopCycle()
{
if (CurPict->CycleOn == 1) {
KillCycle();
LoadRGB4(vp, CurPict->RGBs, Num_vp_Colors);
CurPict->CycleOn = 0;
SetOnString( 0 );
}
}
SelRangeCmd(Msg)
struct IntuiMessage *Msg;
{
struct Gadget *gadget = (struct Gadget *) Msg->IAddress;
int id = gadget->GadgetID;
int newpen;
static int end;
if (WIND_TYPE(id) == CYCTYPE && GADG_TYPE(id) == CYCRNUMS) {
EditRange = GADG_NUM(id);
StopCycle();
/* move current pen to this range's first pen */
BoxPen( CurPen, NORMALPEN );
/* toggle endpoint to display */
if (end ^= 1) {
CurPen = CurPict->Crngs[ EditRange ].low;
} else {
CurPen = CurPict->Crngs[ EditRange ].high;
}
BoxPen( CurPen, MEDIUMPEN );
ModifySpeedPot();
SetDirGadget( CurPict );
ExcludeGadgets( gadget );
}
}
SetDirGadget( Pict )
struct Picture *Pict;
{
int place;
if (Pict) {
if (CycWind) {
place = RemoveGadget(CycWind,DirGadget);
if (Pict->Crngs[EditRange].active & REVERSE) {
DirGadget->Flags &= ~SELECTED;
} else {
DirGadget->Flags |= SELECTED;
}
AddGadget( CycWind, DirGadget, place);
RefreshGList( DirGadget, CycWind, NULL, 1);
}
}
}
ModifySpeedPot()
{
int place;
if (CycWind) {
/* ModifyProp to match EditRange's CycleSpeed */
place = RemoveGadget(CycWind,SpeedPot);
((struct PropInfo *) SpeedPot->SpecialInfo)->HorizPot =
CurPict->Crngs[ EditRange ].rate << 1;
AddGadget( CycWind, SpeedPot, place);
RefreshGList( SpeedPot, CycWind, NULL, 1);
}
}
ExcludeGadgets( gadget )
register struct Gadget *gadget;
{
register struct Gadget *NextGadget;
register place;
NextGadget = gadget;
do {
place = RemoveGadget( CycWind, NextGadget );
if (NextGadget == gadget) {
NextGadget->Flags |= SELECTED;
} else {
NextGadget->Flags &= ~SELECTED;
}
AddGadget( CycWind, NextGadget, place );
RefreshGList( NextGadget, CycWind, NULL, 1);
NextGadget = (struct Gadget *) NextGadget->UserData;
} while ( NextGadget && NextGadget != gadget );
}
static struct PropInfo *PropInfo;
SetSpeed()
{
extern LONG cyClocks[];
CurPict->Crngs[EditRange].rate = PropInfo->HorizPot >> 1;
cyClocks[EditRange] = 0;
}
FinishRangeCmd(pen)
int pen;
{
int t;
if (CurPict == NULL)
return;
t = Num_vp_Colors - 1;
if (RangeFirstPen > t || pen > t)
return;
if (RangeFirstPen > pen) {
t = pen;
pen = RangeFirstPen;
RangeFirstPen = t;
CurPict->Crngs[EditRange].active |= REVERSE;
} else {
CurPict->Crngs[EditRange].active &= ~REVERSE;
}
SetDirGadget( CurPict );
CurPict->Crngs[EditRange].low = RangeFirstPen;
CurPict->Crngs[EditRange].high = pen;
if (pen == RangeFirstPen) {
CurPict->Crngs[EditRange].active &= ~1;
} else {
CurPict->Crngs[EditRange].active |= 1;
}
}
SetOnString( OnOff )
{
int place;
register struct Gadget *SrcGadget,*DstGadget;
if (CycWind == NULL)
return;
if ( OnOff ) {
SrcGadget = CycleOffGadget; /* Make it turn on */
DstGadget = CycleOnGadget;
} else {
SrcGadget = CycleOnGadget;
DstGadget = CycleOffGadget;
}
if (SrcGadget->NextGadget != NULL) {
place = RemoveGadget( CycWind, SrcGadget );
SrcGadget->NextGadget = NULL;
AddGadget( CycWind, DstGadget, place );
SetAPen( CycWind->RPort, NORMALPEN );
RectFill( CycWind->RPort, SrcGadget->LeftEdge, SrcGadget->TopEdge,
SrcGadget->LeftEdge + SrcGadget->Width,
SrcGadget->TopEdge + SrcGadget->Height);
RefreshGList( DstGadget, CycWind, NULL, 1);
}
}
static struct Border *PotBorder;
/*
* Allocate all the gadgets for the color palette window
*/
struct Gadget *MakeCycle()
{
struct Gadget *FirstGadget;
register struct Gadget *NextGadget;
register LONG i,Left,x,y,c = 0;
struct Gadget *ExcludeGadget, *PrevGadget;
struct Image *Image0;
struct Image *Image1;
struct IntuiText *Text, *NextText;
extern struct Image Arrow_Image[];
LONG fourx = 4 << XScale;
LONG foury = 4 << YScale;
char *str;
Left = PENLEFT;
FirstGadget = NextGadget = MakePot( 84, 35, 64, 4, CYCSPEED, y);
if ( NextGadget == NULL ) goto error;
SpeedPot = NextGadget;
NextGadget->Activation = GADGIMMEDIATE | FOLLOWMOUSE | RELVERIFY;
NextGadget->GadgetText = Text = ShadowIntui("Speed",-46, -3);
if ( Text == NULL ) goto error;
Image0 = (struct Image *) NextGadget->GadgetRender;
Image0->Width = 4;
Image0->Height = 4;
Image0->PlaneOnOff = NORMALPEN;
PropInfo = (struct PropInfo *) NextGadget->SpecialInfo;
PropInfo->Flags = PROPBORDERLESS | FREEHORIZ;
PropInfo->HorizBody = 0xff;
PotBorder = ShadowBorder( BEVELEDDOWN, 83, 34, 65, 5);
NextGadget->NextGadget =
MakeBool( LEFTMARG+1, 11, 48, 13, 1, CYCRANGE, NULL);
NextGadget = NextGadget->NextGadget;
if ( NextGadget == NULL) goto error;
NextGadget->GadgetText = ShadowIntui("Range", 4,3);
NextGadget->NextGadget = MakeBool( 151, 32,16, 8, 4, CYCDIR, GADGIMAGE);
NextGadget = NextGadget->NextGadget;
if ( NextGadget == NULL) goto error;
DirGadget = NextGadget;
NextGadget->Flags = GADGHIMAGE | GADGIMAGE | SELECTED;
NextGadget->Activation |= TOGGLESELECT;
Image0 = (struct Image *) NextGadget->GadgetRender;
Image1 = (struct Image *) Image0->NextImage;
Image0->NextImage = NULL;
NextGadget->SelectRender = (APTR) Image1;
SetupArrow(Image0, &Arrow_Image[0]);
SetupArrow(Image1, &Arrow_Image[1]);
CycleOffGadget = MakeBool( 3, 28, 30, 13, 1, CYCON, NULL);
if ( CycleOffGadget == NULL) goto error;
CycleOffGadget->GadgetText = ShadowIntui("Off", 4,4);
CycleOnGadget = MakeBool( 3, 28, 30, 13, 1, CYCON, NULL);
if ( CycleOnGadget == NULL) goto error;
CycleOnGadget->GadgetText = ShadowIntui("On", 8,4);
if (CurPict && CurPict->CycleOn) {
NextGadget->NextGadget = CycleOnGadget;
} else {
NextGadget->NextGadget = CycleOffGadget;
}
NextGadget = NextGadget->NextGadget;
for (c = 0, x = 0; c < 4; c++, x += 28) {
NextGadget->NextGadget =
MakeBool( 55 + x, 11, 24, 13, 1, CYCRNUM+c, NULL);
NextGadget = NextGadget->NextGadget;
if ( NextGadget == NULL ) goto error;
NextGadget->UserData = (APTR) PrevGadget;
PrevGadget = NextGadget;
NextGadget->Flags = GADGHIMAGE;
NextGadget->Activation |= TOGGLESELECT;
NextGadget->SelectRender =
(APTR) ShadowBorder( BEVELEDDOWN, 1, 1, 23, 12);
if (c == 0) {
ExcludeGadget = NextGadget;
NextGadget->Flags |= SELECTED;
EditRange = 0;
}
switch (c) {
case 0: NextGadget->GadgetText = ShadowIntui("c1", 4,3); break;
case 1: NextGadget->GadgetText = ShadowIntui("c2", 4,3); break;
case 2: NextGadget->GadgetText = ShadowIntui("c3", 4,3); break;
case 3: NextGadget->GadgetText = ShadowIntui("c4", 4,3);
}
}
ExcludeGadget->UserData = (APTR) NextGadget;
return(FirstGadget);
error:
FreeGadgets( FirstGadget );
return( NULL );
} /* MakeCycle */
SetupArrow( ImageDst, ImageSrc, )
register struct Image *ImageDst;
register struct Image *ImageSrc;
{
ImageDst->LeftEdge = ImageDst->TopEdge = 0;
ImageDst->Width = 16;
ImageDst->Height = 9;
ImageDst->ImageData = ImageSrc->ImageData;
ImageDst->Depth = 1;
ImageDst->PlanePick = NORMALPEN;
ImageDst->PlaneOnOff = 0;
}
static struct Gadget *CycGadgets;
/*
* Open the Cycle window
*/
OpenCycWind()
{
struct Window *OpenMyWind();
register struct Gadget *gadget;
register struct RastPort *Rp;
if (CurPict == NULL)
return;
if ( CycWind == NULL ) {
gadget = MakeCycle();
if ( gadget == NULL ) {
DispErrMsg("Couldn't get palette gadgets", 0 );
return;
}
CycWind = OpenMyWind( &NewCyc, screen, NULL, 168, 46);
if ( CycWind != NULL ) {
Rp = CycWind->RPort;
SetAPen( Rp, NORMALPEN );
RectFill( Rp, LEFTMARG, TOPMARG, CycWind->Width, CycWind->Height);
BorderWindow( CycWind );
CycGadgets = gadget;
AddGList( CycWind, gadget, -1, -1);
RefreshGadgets( gadget, CycWind, NULL );
DrawBorder( Rp, PotBorder, 0L, 0L);
FreeBorder(PotBorder);
}
} else {
WindowToFront( CycWind );
}
CycleOpen = 1;
} /* OpenCycWind */
/*
* Close the Cycle window
*/
CloseCycWind()
{
register struct Gadget *FreeGadget;
if (CycWind != NULL) {
NewCyc.LeftEdge = CycWind->LeftEdge;
NewCyc.TopEdge = CycWind->TopEdge;
if (CycleOffGadget->NextGadget == NULL) {
FreeGadgets( CycleOffGadget );
} else {
FreeGadgets( CycleOnGadget );
}
CloseMyWind(CycWind,CycGadgets);
CycGadgets = NULL;
}
CycWind = NULL;
} /* CloseCycWind */